package com.kinyx.framework.utils;

import java.util.Map;
import java.util.Map.Entry;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;

import com.kinyx.framework.annotation.assist.CanNotNull;
import com.kinyx.framework.annotation.assist.CanNull;
import com.kinyx.framework.annotation.assist.ReturnNotNull;
import com.kinyx.framework.annotation.assist.ReturnNull;
import com.kinyx.framework.annotation.assist.Tester;
import com.kinyx.framework.function.Handler;

import lombok.AccessLevel;
import lombok.NoArgsConstructor;

/**
 * 字符串工具类
 */
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class KStringUtils {

	/** null字符串 */
	private static final String NULL = "null";

	/**
	 * 处理字符串
	 * @param str 字符串
	 * @param operator 处理器
	 * @return 字符串
	 */
	@ReturnNull("str == null")
	@ReturnNull("str.equals('null')")
	public static String operate(@CanNull final String str, @CanNotNull final UnaryOperator<String> operator) {
		if ((str == null) || str.equals("")) { return str; }
		if (str.equals(NULL)) { return null; }
		return operator.apply(str);
	}

	/**
	 * 将字符串去空
	 * <pre>
		Assert.assertEquals("", KStringUtils.trimToEmpty(null));
		Assert.assertEquals("", KStringUtils.trimToEmpty("null"));
	
		Assert.assertEquals("", KStringUtils.trimToEmpty(""));
		Assert.assertEquals("", KStringUtils.trimToEmpty(" "));
	
		Assert.assertEquals("null", KStringUtils.trimToEmpty(" null "));
		Assert.assertEquals("foo", KStringUtils.trimToEmpty("foo"));
		Assert.assertEquals("foo", KStringUtils.trimToEmpty(" foo "));
	 * </pre>
	 * @param str 字符串
	 * @return 字符串
	 */
	@ReturnNotNull
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_trimToEmpty")
	public static String trimToEmpty(@CanNull final String str) {
		final String result = operate(str, s -> { return s.trim(); });
		return result == null ? "" : result;
	}

	/**
	 * 将字符串去空
	 * <pre>
		Assert.assertEquals(null, KStringUtils.trimToNull(null));
		Assert.assertEquals(null, KStringUtils.trimToNull("null"));
	
		Assert.assertEquals("", KStringUtils.trimToNull(""));
		Assert.assertEquals("", KStringUtils.trimToNull(" "));
	
		Assert.assertEquals("null", KStringUtils.trimToNull(" null "));
		Assert.assertEquals("foo", KStringUtils.trimToNull("foo"));
		Assert.assertEquals("foo", KStringUtils.trimToNull(" foo "));
	 * </pre>
	 * @param str 字符串
	 * @return 字符串
	 */
	@ReturnNull("str == null")
	@ReturnNull("str.equals('null')")
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_trimToNull")
	public static String trimToNull(@CanNull final String str) {
		return operate(str, s -> { return str.trim(); });
	}

	/**
	 * 判断字符串是否为空
	 * <pre>
		Assert.assertTrue(KStringUtils.isBlank(null));
		Assert.assertTrue(KStringUtils.isBlank("null"));
	
		Assert.assertTrue(KStringUtils.isBlank(""));
		Assert.assertTrue(KStringUtils.isBlank(" "));
	
		Assert.assertFalse(KStringUtils.isBlank(" null "));
		Assert.assertFalse(KStringUtils.isBlank("foo"));
		Assert.assertFalse(KStringUtils.isBlank(" foo "));
	 * </pre>
	 * @param str 字符串
	 * @return true：为空；false：不为空；
	 */
	@ReturnNotNull
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_isBlank")
	public static boolean isBlank(@CanNull final String str) {
		return isBlank(str, true);
	}

	/**
	 * 判断字符串是否为空
	 * <pre>
		Assert.assertTrue(KStringUtils.isBlank(null, true));
		Assert.assertTrue(KStringUtils.isBlank("null", true));
	
		Assert.assertTrue(KStringUtils.isBlank("", true));
		Assert.assertTrue(KStringUtils.isBlank(" ", true));
	
		Assert.assertFalse(KStringUtils.isBlank(" null ", true));
		Assert.assertFalse(KStringUtils.isBlank("foo", true));
		Assert.assertFalse(KStringUtils.isBlank(" foo ", true));
	
		Assert.assertTrue(KStringUtils.isBlank(null, false));
		Assert.assertTrue(KStringUtils.isBlank("null", false));
	
		Assert.assertTrue(KStringUtils.isBlank("", false));
		Assert.assertFalse(KStringUtils.isBlank(" ", false));
	
		Assert.assertFalse(KStringUtils.isBlank(" null ", false));
		Assert.assertFalse(KStringUtils.isBlank("foo", false));
		Assert.assertFalse(KStringUtils.isBlank(" foo ", false));
	 * </pre>
	 * @param str 字符串
	 * @param trim true：将字符串去空后判断；false：直接判断；
	 * @return 是否为空
	 */
	@ReturnNotNull
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_isBlank")
	public static boolean isBlank(@CanNull final String str, @CanNotNull final boolean trim) {
		final String result = operate(str, s -> { return trim ? s.trim() : s; });
		if ((result == null) || "".equals(result)) { return true; }
		return false;
	}

	/**
	 * 首字母大写
	 * <pre>
		Assert.assertEquals(null, KStringUtils.capitalize(null));
		Assert.assertEquals(null, KStringUtils.capitalize("null"));
	
		Assert.assertEquals("", KStringUtils.capitalize(""));
		Assert.assertEquals(" ", KStringUtils.capitalize(" "));
	
		Assert.assertEquals(" null ", KStringUtils.capitalize(" null "));
		Assert.assertEquals("Foo", KStringUtils.capitalize("foo"));
		Assert.assertEquals(" foo ", KStringUtils.capitalize(" foo "));
		Assert.assertEquals("Foo", KStringUtils.capitalize("Foo"));
		Assert.assertEquals(" Foo ", KStringUtils.capitalize(" Foo "));
	 * </pre>
	 * @param str 字符串
	 * @return 字符串
	 */
	@ReturnNull("str == null")
	@ReturnNull("str.equals('null')")
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_capitalize")
	public static String capitalize(@CanNull final String str) {
		return operate(str, s -> {
			final char firstChar = s.charAt(0);
			if (!KCharUtils.isLowerCase(firstChar)) { return s; }
			return new StringBuilder().append(KCharUtils.toUpperCase(firstChar)).append(s.substring(1)).toString();
		});
	}

	/**
	 * 首字母小写
	 * <pre>
		Assert.assertEquals(null, KStringUtils.uncapitalize(null));
		Assert.assertEquals(null, KStringUtils.uncapitalize("null"));
	
		Assert.assertEquals("", KStringUtils.uncapitalize(""));
		Assert.assertEquals(" ", KStringUtils.uncapitalize(" "));
	
		Assert.assertEquals(" null ", KStringUtils.uncapitalize(" null "));
		Assert.assertEquals("foo", KStringUtils.uncapitalize("foo"));
		Assert.assertEquals(" foo ", KStringUtils.uncapitalize(" foo "));
		Assert.assertEquals("foo", KStringUtils.uncapitalize("Foo"));
		Assert.assertEquals(" Foo ", KStringUtils.uncapitalize(" Foo "));
	 * </pre>
	 * @param str 字符串
	 * @return 字符串
	 */
	@ReturnNull("str == null")
	@ReturnNull("str.equals('null')")
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_uncapitalize")
	public static String uncapitalize(@CanNull final String str) {
		return operate(str, s -> {
			final char firstChar = s.charAt(0);
			if (!KCharUtils.isUpperCase(firstChar)) { return s; }
			return new StringBuilder().append(KCharUtils.toLowerCase(firstChar)).append(s.substring(1)).toString();
		});
	}

	/**
	 * 下划线转驼峰
	 * <pre>
		Assert.assertEquals(null, KStringUtils.underline2hump(null));
		Assert.assertEquals(null, KStringUtils.underline2hump("null"));
	
		Assert.assertEquals("", KStringUtils.underline2hump(""));
		Assert.assertEquals(" ", KStringUtils.underline2hump(" "));
	
		Assert.assertEquals("fooBarQux", KStringUtils.underline2hump("FOO_BAR_QUX"));
		Assert.assertEquals("malformedUrlException", KStringUtils.underline2hump("MALFORMED_URL_EXCEPTION"));
		Assert.assertEquals("ioException", KStringUtils.underline2hump("IO_EXCEPTION"));
	 * </pre>
	 * @param str 下划线
	 * @return 驼峰
	 */
	@ReturnNull("str == null")
	@ReturnNull("str.equals('null')")
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_underline2hump")
	public static String underline2hump(@CanNull final String str) {
		return operate(str, s -> {
			final StringBuilder sb = new StringBuilder();
			final char[] arr = s.toCharArray();
			boolean flag = false;
			for (int i = 0; i < arr.length; i++) {
				final char charI = arr[i];
				if (flag) {// 下划线的下一位转大写
					sb.append(KCharUtils.isLowerCase(charI) ? KCharUtils.toUpperCase(charI) : charI);
					flag = false;
					continue;
				}
				if (charI == '_') { flag = true; continue; } // 下划线略过
				if (KCharUtils.isUpperCase(charI)) { sb.append(KCharUtils.toLowerCase(charI)); continue; } // 所有大写转小写
				sb.append(charI);
			}
			return sb.toString();
		});
	}

	/**
	 * 驼峰转下划线
	 * <pre>
		Assert.assertEquals(null, KStringUtils.hump2underline(null));
		Assert.assertEquals(null, KStringUtils.hump2underline("null"));
	
		Assert.assertEquals("", KStringUtils.hump2underline(""));
		Assert.assertEquals(" ", KStringUtils.hump2underline(" "));
	
		Assert.assertEquals("FOO_BAR_QUX", KStringUtils.hump2underline("fooBarQux"));
		Assert.assertEquals("MALFORMED_URL_EXCEPTION", KStringUtils.hump2underline("MalformedURLException"));
		Assert.assertEquals("IO_EXCEPTION", KStringUtils.hump2underline("IOException"));
	 * </pre>
	 * @param str 驼峰
	 * @return 下划线
	 */
	@ReturnNull("str == null")
	@ReturnNull("str.equals('null')")
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_hump2underline")
	public static String hump2underline(@CanNull final String str) {
		return hump2words(str, "_", true);
	}

	/**
	 * 驼峰转单词
	 * <pre>
		Assert.assertEquals(null, KStringUtils.hump2words(null, null, true));
		Assert.assertEquals(null, KStringUtils.hump2words("null", null, true));
	
		Assert.assertEquals("", KStringUtils.hump2words("", null, true));
		Assert.assertEquals(" ", KStringUtils.hump2words(" ", null, true));
	
		Assert.assertEquals("FOO BAR QUX", KStringUtils.hump2words("fooBarQux", null, true));
		Assert.assertEquals("MALFORMED URL EXCEPTION", KStringUtils.hump2words("MalformedURLException", null, true));
		Assert.assertEquals("IO EXCEPTION", KStringUtils.hump2words("IOException", null, true));
		
		Assert.assertEquals(null, KStringUtils.hump2words(null, null, false));
		Assert.assertEquals(null, KStringUtils.hump2words("null", null, false));
	
		Assert.assertEquals("", KStringUtils.hump2words("", null, false));
		Assert.assertEquals(" ", KStringUtils.hump2words(" ", null, false));
	
		Assert.assertEquals("foo bar qux", KStringUtils.hump2words("fooBarQux", null, false));
		Assert.assertEquals("malformed URL exception", KStringUtils.hump2words("MalformedURLException", null, false));
		Assert.assertEquals("IO exception", KStringUtils.hump2words("IOException", null, false));
	 * </pre>
	 * @param str 驼峰
	 * @param separator 分隔符
	 * @param upperOrLower true：转大写；false：转小写；
	 * @return 单词
	 */
	@ReturnNull("str == null")
	@ReturnNull("str.equals('null')")
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_hump2words")
	public static String hump2words(@CanNull final String str, @CanNull(defaultValue = " ") final String separator, @CanNotNull final boolean upperOrLower) {
		if (separator == null) { return hump2words(str, " ", upperOrLower); }
		return operate(str, s -> {
			final StringBuilder sb = new StringBuilder();
			final char[] arr = s.toCharArray();
			int pre = 0;// 前一个字符状态。0：无值；1：大写；2：小写；3：其它字符；
			boolean flag = false;// 是否为连续大写
			for (int i = arr.length - 1; i >= 0; i--) {
				final char charI = arr[i];
				if (KCharUtils.isUpperCase(charI)) {// 当前值为大写
					sb.append(upperOrLower ? charI : (pre == 1 ? charI : KCharUtils.toLowerCase(charI)));// 添加当前字符
					// 前一个值为小写，且不是最后一个字符，则补充分隔符。
					if ((pre == 2) && (i != 0)) { sb.append(separator); } // 补充分隔符
					flag = pre == 1;
					pre = 1;
				} else if (KCharUtils.isLowerCase(charI)) {// 当前值为小写
					// 连续大写后出现小写，且不是最后一个字符，则补充分隔符。
					if (flag && (i != 0)) { sb.append(separator); } // 补充分隔符
					sb.append(upperOrLower ? KCharUtils.toUpperCase(charI) : charI);// 添加当前字符
					flag = false;
					pre = 2;
				} else {// 当前值为其它字符
					// 前一个值为大写，且非连续大写，说明已经补充分隔符。
					// 当前值为其它字符，则应删除补充的分隔符。
					if (!flag && (pre == 1)) { sb.deleteCharAt(sb.length() - 1); }
					sb.append(charI);// 直接添加
					flag = false;
					pre = 3;
				}
			}
			return sb.reverse().toString();
		});
	}

	/**
	 * 补零
	 * <pre>
		Assert.assertEquals("3", KStringUtils.fillZero(3, 1));
		Assert.assertEquals("03", KStringUtils.fillZero(3, 2));
		Assert.assertEquals("003", KStringUtils.fillZero(3, 3));
	
		Assert.assertEquals("33", KStringUtils.fillZero(33, 1));
		Assert.assertEquals("33", KStringUtils.fillZero(33, 2));
		Assert.assertEquals("033", KStringUtils.fillZero(33, 3));
	 * </pre>
	 * @param number 当前数字
	 * @param digit 显示位数
	 * @return 补零后的结果
	 */
	@ReturnNotNull
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_fillZero")
	public static String fillZero(@CanNotNull final int number, @CanNotNull final int digit) {
		final String numberStr = String.valueOf(number);
		final int length = numberStr.length();
		if (digit <= length) { return numberStr; }
		final int diff = digit - length;
		final char[] fillArr = new char[diff];
		for (int i = 0; i < diff; i++) {
			fillArr[i] = '0';
		}
		return String.valueOf(fillArr) + numberStr;
	}

	/**
	 * 获取索引值
	 * <pre>
		Assert.assertTrue(-1 == KStringUtils.indexOf(null, null, 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf(null, "null", 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf(null, "", 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf(null, " ", 0));
	
		Assert.assertTrue(-1 == KStringUtils.indexOf("null", null, 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf("null", "null", 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf("null", "", 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf("null", " ", 0));
	
		Assert.assertTrue(-1 == KStringUtils.indexOf("", null, 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf("", "null", 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf("", "", 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf("", " ", 0));
	
		Assert.assertTrue(-1 == KStringUtils.indexOf(" ", null, 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf(" ", "null", 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf(" ", "", 0));
		Assert.assertTrue(0 == KStringUtils.indexOf(" ", " ", 0));
	
		Assert.assertTrue(-1 == KStringUtils.indexOf("a a", null, 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf("a a", "null", 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf("a a", "", 0));
		Assert.assertTrue(1 == KStringUtils.indexOf("a a", " ", 0));
	
		Assert.assertTrue(0 == KStringUtils.indexOf("aaa", "a", 0));
		Assert.assertTrue(1 == KStringUtils.indexOf("aaa", "a", 1));
		Assert.assertTrue(2 == KStringUtils.indexOf("aaa", "a", 2));
	
		Assert.assertTrue(0 == KStringUtils.indexOf("abc", "a", 0));
		Assert.assertTrue(-1 == KStringUtils.indexOf("abc", "a", 1));
		Assert.assertTrue(-1 == KStringUtils.indexOf("abc", "a", 2));
	
		Assert.assertTrue(0 == KStringUtils.indexOf("aba", "a", 0));
		Assert.assertTrue(2 == KStringUtils.indexOf("aba", "a", 1));
		Assert.assertTrue(-1 == KStringUtils.indexOf("aba", "a", 2));
	 * </pre>
	 * @param str 字符串
	 * @param of 查找的字符串
	 * @param num 第几次出现（从0开始）
	 * @return 索引值
	 */
	@ReturnNotNull
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_indexOf")
	public static int indexOf(@CanNull final String str, @CanNull final String of, @CanNotNull final int num) {
		if (isBlank(str, false) || isBlank(of, false)) { return -1; }
		int indexOf = str.indexOf(of);
		if (num < 1) { return indexOf; }
		indexOf++;
		final int nextIndexOf = indexOf(str.substring(indexOf), of, num - 1);
		if (nextIndexOf == -1) { return -1; }
		return nextIndexOf + indexOf;
	}

	/** EL表达式前缀 */
	private static final String EL_PREFIX = "\\$\\{";
	/** EL表达式后缀 */
	private static final String EL_SUFFIX = "\\}";

	/**
	 * 替换EL表达式
	 * <pre>
		Assert.assertEquals(null, KStringUtils.replaceEL(null, null));
		Assert.assertEquals(null, KStringUtils.replaceEL("null", null));
	
		Assert.assertEquals("", KStringUtils.replaceEL("", null));
		Assert.assertEquals(" ", KStringUtils.replaceEL(" ", null));
	
		Assert.assertEquals(" null ", KStringUtils.replaceEL(" null ", null));
		Assert.assertEquals("foo", KStringUtils.replaceEL("foo", null));
		Assert.assertEquals(" foo ", KStringUtils.replaceEL(" foo ", null));
	
		Assert.assertEquals("&#36;{key}", KStringUtils.replaceEL("&#36;{key}", null));
		Assert.assertEquals("foo", KStringUtils.replaceEL("&#36;{key}", new XHashMap&lt;String, Object&gt;().xPut("key", "foo")));
		Assert.assertEquals("from foo to &#36;{to}", KStringUtils.replaceEL("from &#36;{from} to &#36;{to}", new XHashMap&lt;String, Object&gt;().xPut("from", "foo")));
		Assert.assertEquals("from &#36;{from} to bar", KStringUtils.replaceEL("from &#36;{from} to &#36;{to}", new XHashMap&lt;String, Object&gt;().xPut("to", "bar")));
		Assert.assertEquals("from foo to bar", KStringUtils.replaceEL("from &#36;{from} to &#36;{to}", new XHashMap&lt;String, Object&gt;().xPut("from", "foo").xPut("to", "bar")));
	 * </pre>
	 * @param str 字符串
	 * @param params 参数集合
	 * @return 字符串
	 */
	@ReturnNull("str == null")
	@ReturnNull("str.equals('null')")
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_replaceEL")
	public static String replaceEL(@CanNull final String str, @CanNull final Map<String, Object> params) {
		return operate(str, s -> {
			if (params != null) {
				for (final Entry<String, Object> param : params.entrySet()) {
					String value = String.valueOf(param.getValue());
					if ((value != null) && value.contains("$")) {
						value = value.replaceAll("\\$", "\\\\\\$");
					}
					s = s.replaceAll(EL_PREFIX + param.getKey() + EL_SUFFIX, value);
				}
			}
			return s.toString();
		});
	}

	/**
	 * 校验非空
	 * @param str 字符串
	 * @param blank 当str为空时，自定义实现。
	 * @return 字符串
	 */
	@ReturnNull("str为空，自定义blank实现返回null。")
	public static String checkBlank(final String str, final Supplier<String> blank) {
		if (KStringUtils.isBlank(str)) {
			return blank.get();
		}
		return str;
	}

	/**
	 * 校验非空并做比较
	 * <pre>
	 * str1为空，str2不为空时，返回str2。
	 * str1不为空，str2为空时，返回str1。
	 * str1为空，str2为空时，返回bothBlank实现的结果。
	 * str1不为空，str2不为空时，str1.equals(str2)，则返回str1值。
	 * str1不为空，str2不为空时，!str1.equals(str2)，则返回null值。
	 * </pre>
	 * @param str1 字符串1
	 * @param str2 字符串2
	 * @param bothBlank 当str1和str2都为空时，自定义实现。
	 * @param notEquals 当str1和str2都不为空且值不一致时，自定义实现。
	 * @return 字符串
	 */
	@ReturnNull("str1为空，str2为空时，自定义bothBlank实现返回null。")
	@ReturnNull("str1不为空，str2不为空时，!str1.equals(str2)。")
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_checkBlankAndCompare")
	public static String checkBlankAndCompare(final String str1, final String str2, final Supplier<String> bothBlank, final Handler notEquals) {
		if (KStringUtils.isBlank(str1)) {
			if (KStringUtils.isBlank(str2)) {
				return bothBlank.get();
			} else {
				return str2;
			}
		} else {
			if (KStringUtils.isBlank(str2)) {
				return str1;
			} else {
				if (str1.equals(str2)) {
					return str1;
				} else {
					notEquals.handle();
					return null;
				}
			}
		}
	}

	/**
	 * 校验非空并做比较
	 * <pre>
	 * 全为为空时，返回bothBlank实现的结果。
	 * 只有一个不为空时，返回该值。
	 * 多于一个不为空时，不匹配时，则返回null值。
	 * </pre>
	 * @param str1 字符串1
	 * @param str2 字符串2
	 * @param str3 字符串3
	 * @param bothBlank 当str1和str2和str3都为空时，自定义实现。
	 * @param notEquals12 当str1和str2都不为空且值不一致时，自定义实现。
	 * @param notEquals13 当str1和str3都不为空且值不一致时，自定义实现。
	 * @param notEquals23 当str2和str3都不为空且值不一致时，自定义实现。
	 * @return 字符串
	 */
	@ReturnNull("全为为空时，自定义实现bothBlank返回null。")
	@ReturnNull("多于一个不为空时，不匹配时，则返回null值。")
	@Tester("com.kinyx.framework.utils.KStringUtils_Tester_checkBlankAndCompare")
	public static String checkBlankAndCompare(final String str1, final String str2, final String str3, final Supplier<String> bothBlank, final Handler notEquals12, final Handler notEquals13, final Handler notEquals23) {
		if (KStringUtils.isBlank(str1)) {
			if (KStringUtils.isBlank(str2)) {
				if (KStringUtils.isBlank(str3)) {
					return bothBlank.get();
				} else {
					return str3;
				}
			} else {
				if (KStringUtils.isBlank(str3)) {
					return str2;
				} else {
					if (str2.equals(str3)) {
						return str2;
					} else {
						notEquals23.handle();
						return null;
					}
				}
			}
		} else {
			if (KStringUtils.isBlank(str2)) {
				if (KStringUtils.isBlank(str3)) {
					return str1;
				} else {
					if (str1.equals(str3)) {
						return str1;
					} else {
						notEquals13.handle();
						return null;
					}
				}
			} else {
				if (str1.equals(str2)) {
					if (KStringUtils.isBlank(str3)) {
						return str1;
					} else {
						if (str1.equals(str3)) {
							return str1;
						} else {
							notEquals13.handle();
							return null;
						}
					}
				} else {
					notEquals12.handle();
					return null;
				}
			}
		}
	}

}
